package com.school.controller;

import com.school.entity.User;
import com.school.service.UserService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Optional;
import java.util.stream.Collectors;

@RestController
@RequestMapping("/api/user")
public class UserController {
    @Autowired
    private UserService userService;

    @Autowired
    private com.school.service.StudentService studentService;

    /**
     * 获取用户列表
     * @param role 角色（可选）
     * @param keyword 关键字（可选，用于搜索用户名或姓名）
     * @param classId 班级ID（可选，用于筛选学生）
     * @param currentUsername 当前用户名（可选，用于权限控制）
     * @return 用户列表
     */
    @GetMapping("/list")
    public List<Map<String, Object>> list(
            @RequestParam(required = false) String role,
            @RequestParam(required = false) String keyword,
            @RequestParam(required = false) Integer classId,
            @RequestParam(required = false) String currentUsername) {

        List<User> users;

        // 处理角色参数
        if (role != null && !role.isEmpty()) {
            // 如果是学生角色且指定了班级ID
            if ("student".equals(role) && classId != null) {
                // 获取指定班级的学生
                users = userService.findByRoleAndClassId(role, classId);

                // 如果有关键字，进一步筛选
                if (keyword != null && !keyword.isEmpty()) {
                    users = users.stream()
                            .filter(user ->
                                (user.getUsername() != null && user.getUsername().contains(keyword)) ||
                                (user.getName() != null && user.getName().contains(keyword)) ||
                                (user.getStudentId() != null && user.getStudentId().contains(keyword)))
                            .collect(Collectors.toList());
                }
            } else {
                // 按角色查询
                users = userService.findByRole(role);

                // 如果有关键字，进一步筛选
                if (keyword != null && !keyword.isEmpty()) {
                    users = users.stream()
                            .filter(user ->
                                (user.getUsername() != null && user.getUsername().contains(keyword)) ||
                                (user.getName() != null && user.getName().contains(keyword)) ||
                                ("student".equals(role) && user.getStudentId() != null && user.getStudentId().contains(keyword)))
                            .collect(Collectors.toList());
                }
            }
        } else if (keyword != null && !keyword.isEmpty()) {
            // 如果只有关键字，则在所有用户中搜索
            users = userService.findAll().stream()
                    .filter(user ->
                        (user.getUsername() != null && user.getUsername().contains(keyword)) ||
                        (user.getName() != null && user.getName().contains(keyword)) ||
                        (user.getStudentId() != null && user.getStudentId().contains(keyword)))
                    .collect(Collectors.toList());
        } else {
            // 如果没有任何参数，返回所有用户
            users = userService.findAll();
        }

        // 转换为前端需要的格式，不返回密码等敏感信息
        return users.stream().map(user -> {
            Map<String, Object> map = new HashMap<>();
            map.put("id", user.getId());
            map.put("username", user.getUsername());
            map.put("name", user.getName());
            map.put("role", user.getRole());
            map.put("phone", user.getPhone());
            map.put("studentId", user.getStudentId());
            map.put("classId", user.getClassId());
            map.put("status", "正常"); // 目前没有状态字段，默认为正常
            return map;
        }).collect(Collectors.toList());
    }

    /**
     * 添加用户
     */
    @PostMapping("/add")
    public Map<String, Object> add(@RequestBody User user) {
        Map<String, Object> result = new HashMap<>();

        // 检查用户名是否已存在
        if (userService.findByUsername(user.getUsername()).isPresent()) {
            result.put("success", false);
            result.put("message", "用户名已存在");
            return result;
        }

        // 如果是学生角色，检查学号是否已存在
        if ("student".equals(user.getRole()) && user.getStudentId() != null &&
            userService.findByStudentId(user.getStudentId()).isPresent()) {
            result.put("success", false);
            result.put("message", "学号已存在");
            return result;
        }

        // 如果没有设置密码，则默认密码与用户名相同
        if (user.getPassword() == null || user.getPassword().isEmpty()) {
            user.setPassword(user.getUsername());
        }

        userService.save(user);

        result.put("success", true);
        return result;
    }

    /**
     * 编辑用户
     */
    @PostMapping("/edit")
    public Map<String, Object> edit(@RequestBody User user) {
        Map<String, Object> result = new HashMap<>();

        // 检查用户是否存在
        Optional<User> existingUser = userService.findById(user.getId());
        if (existingUser.isEmpty()) {
            result.put("success", false);
            result.put("message", "用户不存在");
            return result;
        }

        // 检查用户名是否与其他用户重复
        Optional<User> userWithSameUsername = userService.findByUsername(user.getUsername());
        if (userWithSameUsername.isPresent() && !userWithSameUsername.get().getId().equals(user.getId())) {
            result.put("success", false);
            result.put("message", "用户名已被其他用户使用");
            return result;
        }

        // 如果是学生角色，检查学号是否与其他用户重复
        if ("student".equals(user.getRole()) && user.getStudentId() != null) {
            Optional<User> userWithSameStudentId = userService.findByStudentId(user.getStudentId());
            if (userWithSameStudentId.isPresent() && !userWithSameStudentId.get().getId().equals(user.getId())) {
                result.put("success", false);
                result.put("message", "学号已被其他用户使用");
                return result;
            }
        }

        // 更新用户信息，但不更新密码
        User existing = existingUser.get();
        existing.setUsername(user.getUsername());
        existing.setName(user.getName());
        existing.setRole(user.getRole());
        existing.setPhone(user.getPhone());
        existing.setStudentId(user.getStudentId());
        existing.setClassId(user.getClassId());

        userService.save(existing);

        result.put("success", true);
        return result;
    }

    /**
     * 删除用户
     */
    @PostMapping("/delete")
    public Map<String, Object> delete(@RequestBody Map<String, Object> param, @RequestParam(required = false) String currentUsername) {
        Map<String, Object> result = new HashMap<>();

        if (!param.containsKey("id")) {
            result.put("success", false);
            result.put("message", "参数错误");
            return result;
        }

        Long id = Long.valueOf(param.get("id").toString());
        Optional<User> targetUser = userService.findById(id);

        if (targetUser.isEmpty()) {
            result.put("success", false);
            result.put("message", "用户不存在");
            return result;
        }

        // 获取当前操作用户
        Optional<User> currentUser = userService.findByUsername(currentUsername != null ? currentUsername : "admin");
        if (currentUser.isEmpty()) {
            result.put("success", false);
            result.put("message", "当前用户信息获取失败");
            return result;
        }

        User target = targetUser.get();
        User current = currentUser.get();

        // 检查是否是初始管理员（ID为1的用户）
        if (target.getId() == 1) {
            result.put("success", false);
            result.put("message", "初始管理员不能被删除");
            return result;
        }

        // 检查权限
        if ("admin".equals(target.getRole())) {
            // 只有初始管理员可以删除其他管理员
            if (current.getId() != 1) {
                result.put("success", false);
                result.put("message", "您没有权限删除管理员");
                return result;
            }
        }

        // 如果是学生用户，先删除学生记录
        if ("student".equals(target.getRole()) && target.getStudentId() != null) {
            // 查找对应的学生记录
            studentService.findByStudentId(target.getStudentId()).ifPresent(student -> {
                // 删除学生记录（这会级联删除考勤记录）
                studentService.deleteById(student.getId());
            });
        } else {
            // 非学生用户，直接删除用户记录
            userService.deleteById(id);
        }

        result.put("success", true);
        return result;
    }

    /**
     * 重置用户密码
     */
    @PostMapping("/resetPassword")
    public Map<String, Object> resetPassword(@RequestBody Map<String, Object> param) {
        Map<String, Object> result = new HashMap<>();

        if (!param.containsKey("id")) {
            result.put("success", false);
            result.put("message", "参数错误");
            return result;
        }

        Long id = Long.valueOf(param.get("id").toString());
        if (userService.findById(id).isEmpty()) {
            result.put("success", false);
            result.put("message", "用户不存在");
            return result;
        }

        userService.resetPassword(id);

        result.put("success", true);
        return result;
    }

    /**
     * 修改密码
     */
    @PostMapping("/changePassword")
    public Map<String, Object> changePassword(@RequestBody Map<String, Object> param) {
        Map<String, Object> result = new HashMap<>();

        // 验证参数
        if (!param.containsKey("username") || !param.containsKey("oldPassword") || !param.containsKey("newPassword")) {
            result.put("success", false);
            result.put("message", "参数错误");
            return result;
        }

        String username = param.get("username").toString();
        String oldPassword = param.get("oldPassword").toString();
        String newPassword = param.get("newPassword").toString();

        // 查找用户
        Optional<User> userOpt = userService.findByUsername(username);
        if (userOpt.isEmpty()) {
            result.put("success", false);
            result.put("message", "用户不存在");
            return result;
        }

        User user = userOpt.get();

        // 验证原密码
        if (!userService.checkPassword(user, oldPassword)) {
            result.put("success", false);
            result.put("message", "原密码错误");
            return result;
        }

        // 更新密码
        userService.updatePassword(user.getId(), newPassword);

        result.put("success", true);
        return result;
    }

    /**
     * 获取用户详情（通过ID）
     */
    @GetMapping("/detail")
    public Map<String, Object> detail(@RequestParam Long id) {
        Map<String, Object> result = new HashMap<>();

        Optional<User> user = userService.findById(id);
        if (user.isEmpty()) {
            result.put("success", false);
            result.put("message", "用户不存在");
            return result;
        }

        result.put("success", true);

        // 不返回密码等敏感信息
        Map<String, Object> data = new HashMap<>();
        data.put("id", user.get().getId());
        data.put("username", user.get().getUsername());
        data.put("name", user.get().getName());
        data.put("role", user.get().getRole());
        data.put("phone", user.get().getPhone());
        data.put("studentId", user.get().getStudentId());
        data.put("classId", user.get().getClassId());

        result.put("data", data);

        return result;
    }

    /**
     * 获取用户信息（通过用户名）
     * 用于个人信息页面
     */
    @GetMapping("/info")
    public Map<String, Object> info(@RequestParam String username) {
        Map<String, Object> result = new HashMap<>();

        Optional<User> user = userService.findByUsername(username);
        if (user.isEmpty()) {
            result.put("success", false);
            result.put("message", "用户不存在");
            return result;
        }

        result.put("success", true);

        // 不返回密码等敏感信息
        Map<String, Object> data = new HashMap<>();
        data.put("id", user.get().getId());
        data.put("username", user.get().getUsername());
        data.put("name", user.get().getName());
        data.put("role", user.get().getRole());
        data.put("phone", user.get().getPhone());
        data.put("studentId", user.get().getStudentId());
        data.put("classId", user.get().getClassId());

        result.put("data", data);

        return result;
    }

    /**
     * 用户登录
     */
    @PostMapping("/login")
    public Map<String, Object> login(@RequestBody Map<String, String> loginInfo) {
        Map<String, Object> result = new HashMap<>();

        // 验证参数
        if (!loginInfo.containsKey("username") || !loginInfo.containsKey("password")) {
            result.put("success", false);
            result.put("message", "用户名和密码不能为空");
            return result;
        }

        String username = loginInfo.get("username");
        String password = loginInfo.get("password");

        // 特殊处理初始管理员账号
        if ("admin".equals(username) && "admin123".equals(password)) {
            result.put("success", true);
            result.put("role", "admin");
            result.put("name", "管理员");
            result.put("id", 1);
            return result;
        }

        // 查找用户
        Optional<User> userOpt = userService.findByUsername(username);
        if (userOpt.isEmpty()) {
            result.put("success", false);
            result.put("message", "用户不存在");
            return result;
        }

        User user = userOpt.get();

        // 验证密码
        if (!userService.checkPassword(user, password)) {
            result.put("success", false);
            result.put("message", "密码错误");
            return result;
        }

        // 登录成功
        result.put("success", true);
        result.put("role", user.getRole());
        result.put("name", user.getName());
        result.put("id", user.getId());

        return result;
    }
}
